home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / lists / mint / l_1199 / 1717 < prev    next >
Encoding:
Internet Message Format  |  1994-08-27  |  37.5 KB
  1. Subject: Re: MiNTlib (I think I'm on pl43): Bug in sprintf().
  2. Date: Mon, 18 Jul 94 1:45:36 CDT
  3. From: Juergen Lock <nox@jelal.north.de>
  4. In-Reply-To: <9407130621.AA25156@hera.rbi.informatik.uni-frankfurt.de>; from "Kay Roemer" at Jul 13, 94 8:21 am
  5. Message-Id: <9407172345.AA00280@jelal.north.de>
  6.  
  7. Kay Roemer writes:
  8.  
  9. > > Probably normal, given that it's really polling at 60 times per second.
  10. > > So up to 30-some characters can arrive (at 19200) before polling, and then
  11. > > checkbttys is only called on a context switch, so yes, there could be a
  12. > > large number of characters waiting before select returns...
  13. > 
  14. > Well, I'm not taking of 30 characters, but about a screen full of them, ie
  15. > about 80x25=2000! When I use modm0dev which polls at 5 times per second
  16. > using a separate porcess I get much smaller hunks, about 500.
  17.  
  18.  thats on a 68000 right?  i guess you just found the `feature' that a
  19. RAW tty read is slower copying stuff out of the receiver buffer than
  20. data comes in at 19200 bps...  sounds unbelievable hmm? ;)  well, try this!
  21. (relative to 10h6)
  22.  
  23. 1. fix range checks, eliminate some dead code...
  24.  
  25. Index: bios.c
  26. @@ -80,24 +80,24 @@
  27.  
  28.  /* and then do BCOSTAT ourselves, the BIOS SCC ones are often broken */
  29.  #define BCOSTAT(dev) \
  30. -    (((unsigned)dev <= 4 && tosvers > 0x0102) ? \
  31. -       (int)callout1(xcostat[dev], dev) : \
  32. -       ((has_bconmap && (unsigned)((dev-SERDEV) <= btty_max)) ? \
  33. +    (((unsigned)dev <= 4) ? ((tosvers > 0x0102) ? \
  34. +       (int)callout1(xcostat[dev], dev) : Bcostat(dev)) : \
  35. +       ((has_bconmap && (unsigned)dev-SERDEV < btty_max) ? \
  36.          bcxstat(MAPTAB[dev-SERDEV].iorec+1) : Bcostat(dev)))
  37.  #define BCONOUT(dev, c) \
  38. -    (((unsigned)dev <= 4 && tosvers > 0x0102) ? \
  39. -       callout2(xconout[dev], dev, c) : \
  40. -       ((has_bconmap && (unsigned)((dev-SERDEV) <= btty_max)) ? \
  41. +    (((unsigned)dev <= 4) ? ((tosvers > 0x0102) ? \
  42. +       callout2(xconout[dev], dev, c) : Bconout(dev, c)) : \
  43. +       ((has_bconmap && (unsigned)dev-SERDEV < btty_max) ? \
  44.          callout2(MAPTAB[dev-SERDEV].bconout, dev, c) : Bconout(dev, c)))
  45.  #define BCONSTAT(dev) \
  46. -    (((unsigned)dev <= 4 && tosvers > 0x0102) ? \
  47. -       (int)callout1(xconstat[dev], dev) : \
  48. -       ((has_bconmap && (unsigned)((dev-SERDEV) <= btty_max)) ? \
  49. +    (((unsigned)dev <= 4) ? ((tosvers > 0x0102) ? \
  50. +       (int)callout1(xconstat[dev], dev) : Bconstat(dev)) : \
  51. +       ((has_bconmap && (unsigned)dev-SERDEV < btty_max) ? \
  52.          (int)callout1(MAPTAB[dev-SERDEV].bconstat, dev) : Bconstat(dev)))
  53.  #define BCONIN(dev) \
  54. -    (((unsigned)dev <= 4 && tosvers > 0x0102) ? \
  55. -       callout1(xconin[dev], dev) : \
  56. -       ((has_bconmap && (unsigned)((dev-SERDEV) <= btty_max)) ? \
  57. +    (((unsigned)dev <= 4) ? ((tosvers > 0x0102) ? \
  58. +       callout1(xconin[dev], dev) : Bconin(dev)) : \
  59. +       ((has_bconmap && (unsigned)dev-SERDEV < btty_max) ? \
  60.          callout1(MAPTAB[dev-SERDEV].bconin, dev) : Bconin(dev)))
  61.  #else
  62.  #define BCOSTAT(dev) \
  63. @@ -264,7 +264,14 @@
  64.          } else
  65.              h = dev-SERDEV;
  66.  
  67. -        if (h >= 0 && h < btty_max) {
  68. +        if ((unsigned)h < btty_max) {
  69. +            if (has_bconmap) {    /* help the compiler... :) */
  70. +                long *statc;
  71. +
  72. +                while (!callout1(*(statc=&MAPTAB[dev-SERDEV].bconstat), dev))
  73. +                    sleep(IO_Q, (long)&bttys[h]);
  74. +                return callout1(statc[1], dev);
  75. +            }
  76.              while (!BCONSTAT(dev))
  77.                  sleep(IO_Q, (long)&bttys[h]);
  78.          } else if (dev > 0) {
  79. Index: xbios.c
  80. @@ -145,10 +145,12 @@
  81.  uiorec(dev)
  82.      int dev;
  83.  {
  84. +    extern short btty_max;
  85. +
  86.      TRACE(("Iorec(%d)", dev));
  87.      if (dev == 0 && has_bconmap) {
  88.  /* get around another BIOS Bug:  in (at least) TOS 2.05 Iorec(0) is broken */
  89. -        if (curproc->bconmap >= 6)
  90. +        if ((unsigned)curproc->bconmap-6 < btty_max)
  91.              return (long)MAPTAB[curproc->bconmap-6].iorec;
  92.          mapin(curproc->bconmap);
  93.      }
  94. @@ -174,7 +176,7 @@
  95.  /* more bugs...  serial1 is three-wire, requesting hardware flowcontrol
  96.   * on it can confuse BIOS
  97.   */
  98. -        if ((flow & 2) && (unsigned)curproc->bconmap-6 <= btty_max &&
  99. +        if ((flow & 2) && (unsigned)curproc->bconmap-6 < btty_max &&
  100.              bttys[curproc->bconmap-6].rsel == &(ttmfp_tty.rsel))
  101.              flow &= ~2;
  102.  
  103. 2. serial lines, act 2
  104.  
  105. anyone remember my idea to add shortcuts for fast RAW tty IO in the DEVDRV
  106. struct?  well, looks like it works.  i can receive and display(!) nearly
  107. full 57600 bps now using my hack of howards little `tip' program...
  108. a while ago the same program had problems at 19200 and this 68000 runs
  109. at 16 MHz.  so its a factor >= 3 including output!
  110.  
  111. the iread() and iwrite() are mostly the ones i patched into taylor uucp 1.03
  112. so they have been tested for some time.  i hope 1.05 will no longer need
  113. any such hacks now... (imagine uucp-i on a ST :)
  114.  
  115. oh and memcpy is an extended quickmove really (quickmovb), and the XDEF'd
  116. _bcopy is just a hint for gcc that it doesn't need to load the libs
  117. bcopy too.
  118.  
  119. Index: file.h
  120. @@ -141,7 +141,15 @@
  121.      long ARGS_ON_STACK (*datime)    P_((FILEPTR *f, short *timeptr, int rwflag));
  122.      long ARGS_ON_STACK (*close)    P_((FILEPTR *f, int pid));
  123.      long ARGS_ON_STACK (*select)    P_((FILEPTR *f, long proc, int mode));
  124. -    void ARGS_ON_STACK (*unselect) P_((FILEPTR *f, long proc, int mode));
  125. +    void ARGS_ON_STACK (*unselect)    P_((FILEPTR *f, long proc, int mode));
  126. +/* extensions, check dev_descr.drvsize (size of DEVDRV struct) before calling:
  127. + * fast RAW tty byte io  */
  128. +    long ARGS_ON_STACK (*writeb)    P_((FILEPTR *f, const char *buf, long bytes));
  129. +    long ARGS_ON_STACK (*readb)    P_((FILEPTR *f, char *buf, long bytes));
  130. +/* what about: scatter/gather io for DMA devices...
  131. + *    long ARGS_ON_STACK (*writev)    P_((FILEPTR *f, const struct iovec *iov, long cnt));
  132. + *    long ARGS_ON_STACK (*readv)    P_((FILEPTR *f, const struct iovec *iov, long cnt));
  133. + */
  134.  } DEVDRV;
  135.  
  136.  typedef struct filesys {
  137. @@ -509,6 +517,8 @@
  138.      long        *rsel;        /* pointer to field in tty struct */
  139.      IOREC_T        *orec;        /* Same, for output... */
  140.      long        *wsel;
  141. +    long        ispeed, ospeed;
  142. +    long        *baudmap, maxbaud;
  143.  };
  144.  
  145.  /* Dcntl constants and types */
  146. @@ -521,7 +531,8 @@
  147.      short    dinfo;
  148.      short    flags;
  149.      struct tty *tty;
  150. -    long    reserved[4];
  151. +    long    drvsize;        /* size of DEVDRV struct */
  152. +    long    reserved[3];
  153.  };
  154.  
  155.  
  156. @@ -582,6 +593,7 @@
  157.      struct bios_file *next;
  158.      short    lockpid;        /* owner of the lock */
  159.      XATTR    xattr;            /* guess what... */
  160. +    long    drvsize;        /* size of DEVDRV struct */
  161.  };
  162.  
  163.  #endif /* _filesys_h */
  164. Index: mint.h
  165. @@ -139,6 +139,7 @@
  166.  #define strlwr    MS_lwr
  167.  #define strupr    MS_upr
  168.  #define sleep    M_sleep
  169. +#define memcpy    quickmovb
  170.  #endif
  171.  
  172.  #ifdef SHORT_NAMES
  173. @@ -170,6 +171,10 @@
  174.  #include "proto.h"
  175.  #include "sproto.h"
  176.  #endif
  177. +
  178. +#ifndef offsetof
  179. +#include <stddef.h>
  180. +#endif
  181.  
  182.  #ifndef NULL
  183.  #define NULL ((void *)0)
  184. Index: proto.h
  185. @@ -298,6 +298,7 @@
  186.  
  187.  /* tty.c */
  188.  long tty_read P_((FILEPTR *f, void *buf, long nbytes));
  189. +INLINE void tty_checkttou P_((FILEPTR *f, struct tty *tty));
  190.  long tty_write P_((FILEPTR *f, const void *buf, long nbytes));
  191.  long tty_ioctl P_((FILEPTR *f, int mode, void *arg));
  192.  long tty_getchar P_((FILEPTR *f, int mode));
  193. @@ -336,6 +337,8 @@
  194.  
  195.  /* biosfs.c */
  196.  void biosfs_init P_((void));
  197. +long iwrite    P_((int bdev, const char *buf, long bytes, int ndelay, struct bios_file *b));
  198. +long iread    P_((int bdev, char *buf, long bytes, int ndelay, struct bios_file *b));
  199.  void ARGS_ON_STACK mouse_handler P_((const char *buf));
  200.  long ARGS_ON_STACK nocreat P_((fcookie *dir, const char *name, unsigned mode, int attrib,
  201.           fcookie *fc));
  202. Index: bios.c
  203. @@ -694,7 +694,11 @@
  204.              return 0;
  205.          }
  206.          if (is_terminal(f)) {
  207. +            int oldflags = f->flags;
  208. +
  209.              s = bconbuf;
  210. +/* turn off NDELAY for this write... */
  211. +            f->flags &= ~O_NDELAY;
  212.              if (dev == 5) {
  213.                  while (bsiz-- > 0) {
  214.                  if (*s < ' ') {
  215. @@ -710,6 +714,24 @@
  216.  #if 1
  217.                  long *where, nbytes;
  218.  
  219. +#if 1
  220. +                extern FILESYS bios_filesys;
  221. +
  222. +                /* see if we can do fast RAW byte IO thru the device driver... */
  223. +                if ((f->fc.fs != &bios_filesys ||
  224. +                    (bsiz > 1 &&
  225. +                     ((struct bios_file *)f->fc.index)->drvsize >
  226. +                        offsetof (DEVDRV, writeb))) && *f->dev->writeb) {
  227. +                    struct tty *tty = (struct tty *)f->devinfo;
  228. +
  229. +                tty_checkttou (f, tty);
  230. +                if ((ret = (*f->dev->writeb)(f, s, bsiz)) != EUNDEV) {
  231. +                    f->flags = oldflags;
  232. +                    bconbdev = 0;
  233. +                    return ret;
  234. +                }
  235. +                }
  236. +#endif
  237.  /* the tty_putchar should set up terminal modes correctly */
  238.                  (void) tty_putchar(f, (long)*s++, RAW);
  239.                  where = lbconbuf;
  240. @@ -726,6 +748,7 @@
  241.  #endif
  242.              }
  243.              ret = -1;
  244. +            f->flags = oldflags;
  245.          } else {
  246.              ret = (*f->dev->write)(f, (char *)bconbuf, bsiz);
  247.          }
  248. @@ -739,6 +762,10 @@
  249.          dev = curproc->bconmap;
  250.          statdev = dev;
  251.      }
  252. +    if ((ret = iwrite (dev, bconbuf, bsiz, 0, 0)) != EUNDEV) {
  253. +        bconbdev = 0;
  254. +        return ret;
  255. +    }
  256.  /* compensate for a known BIOS bug; MIDI and IKBD are switched */
  257.      else if (dev == 3) {        /* MIDI */
  258.          statdev = 4;
  259. Index: biosfs.c
  260. @@ -35,6 +35,8 @@
  261.  static long    ARGS_ON_STACK bios_topen    P_((FILEPTR *f));
  262.  static long    ARGS_ON_STACK bios_twrite    P_((FILEPTR *f, const char *buf, long bytes));
  263.  static long    ARGS_ON_STACK bios_tread    P_((FILEPTR *f, char *buf, long bytes));
  264. +static long    ARGS_ON_STACK bios_writeb    P_((FILEPTR *f, const char *buf, long bytes));
  265. +static long    ARGS_ON_STACK bios_readb    P_((FILEPTR *f, char *buf, long bytes));
  266.  static long    ARGS_ON_STACK bios_nwrite    P_((FILEPTR *f, const char *buf, long bytes));
  267.  static long    ARGS_ON_STACK bios_nread    P_((FILEPTR *f, char *buf, long bytes));
  268.  static long    ARGS_ON_STACK bios_ioctl    P_((FILEPTR *f, int mode, void *buf));
  269. @@ -64,7 +66,8 @@
  270.  
  271.  DEVDRV bios_tdevice = {
  272.      bios_topen, bios_twrite, bios_tread, bios_tseek, bios_ioctl,
  273. -    null_datime, bios_close, bios_select, bios_unselect
  274. +    null_datime, bios_close, bios_select, bios_unselect,
  275. +    bios_writeb, bios_readb
  276.  };
  277.  
  278.  /* device driver for BIOS devices that are not terminals */
  279. @@ -146,9 +149,22 @@
  280.      {"", 0, 0, 0, 0, 0}
  281.  };
  282.  
  283. +#define xconstat ((long *)0x51eL)
  284. +#define xconin     ((long *)0x53eL)
  285. +#define xcostat ((long *)0x55eL)
  286. +#define xconout    ((long *)0x57eL)
  287. +
  288.  extern BCONMAP2_T *bconmap2;        /* bconmap struct */
  289.  #define MAPTAB (bconmap2->maptab)
  290.  
  291. +#define MAXBAUD 16
  292. +
  293. +/* keep these sorted in descending order */
  294. +static long baudmap[MAXBAUD] = {
  295. +19200L, 9600L, 4800L, 3600L, 2400L, 2000L, 1800L, 1200L,
  296. +600L, 300L, 200L, 150L, 134L, 110L, 75L, 50L
  297. +};
  298. +
  299.  /* set/reset bits in SCC w5 */
  300.  INLINE static void scc_set5 (control, setp, bits, iorec)
  301.  volatile char *control;
  302. @@ -183,6 +199,8 @@
  303.  struct bios_tty bttys[MAX_BTTY];
  304.  short    btty_max;
  305.  
  306. +extern int tosvers;    /* from main.c */
  307. +
  308.  /* Does the fcookie fc refer to the \dev\fd directory? */
  309.  #define IS_FD_DIR(fc) ((fc)->aux == S_IFDIR)
  310.  /* Does the fcookie fc refer to a file in the \dev\fd directory? */
  311. @@ -254,6 +272,10 @@
  312.      /* Save a pointer to the first serial port */
  313.          if (b->private == 6)
  314.              c = b;
  315. +        if (b->device->readb && b->tty != &con_tty)
  316. +    /* device has DEVDRV calls beyond unselect */
  317. +            b->drvsize = offsetof (DEVDRV, readb) + sizeof (long);
  318. +
  319.      /* if not a TT or Mega STE, adjust the MODEM1 device to be BIOS
  320.       * device 1
  321.       * and ignore the remaining devices, since they're not present
  322. @@ -281,12 +303,18 @@
  323.      }
  324.      /* Initialize bios_tty structures */
  325.      for (i=0;c && i<MAX_BTTY;c=c->next, i++) {
  326. +        unsigned r;
  327.          if (has_bconmap)
  328.              Bconmap(c->private);
  329.          bttys[i].irec = Iorec(0);
  330.          bttys[i].orec = bttys[i].irec+1;
  331.          bttys[i].rsel = &(c->tty->rsel);
  332.          bttys[i].wsel = &(c->tty->wsel);
  333. +        bttys[i].baudmap = baudmap;
  334. +        bttys[i].maxbaud = MAXBAUD;
  335. +        r = (int)rsconf(-2, -1, -1, -1, -1, -1);
  336. +        Rsconf(r, -1, -1, -1, -1, -1);
  337. +        bttys[i].ospeed = bttys[i].ispeed = r<MAXBAUD ? baudmap[r] : -1;
  338.      }
  339.      btty_max = i;
  340.  
  341. @@ -788,6 +816,7 @@
  342.   *       short  dinfo            info for the device driver
  343.   *       short  flags            flags for the file (e.g. O_TTY)
  344.   *       struct tty *tty        tty structure, if appropriate
  345. + *       long   drvsize;        size of driver struct
  346.   *
  347.   * Dcntl(0xde00, "U:\DEV\BAR", n): install a new BIOS terminal device, with
  348.   *     BIOS device number "n".
  349. @@ -835,6 +864,7 @@
  350.              b->private = d->dinfo;
  351.              b->flags = d->flags;
  352.              b->tty = d->tty;
  353. +            b->drvsize = d->drvsize;
  354.              set_xattr(&(b->xattr), S_IFCHR|DEFAULT_MODE, UNK_RDEV|devindex);
  355.              devindex = (devindex+1) & 0x00ff;
  356.              return (long)&kernelinfo;
  357. @@ -865,7 +895,11 @@
  358.                      return ENSMEM;
  359.                  b->tty = ttyptr;
  360.              }
  361. +            b->drvsize = 0;
  362.              b->device = &bios_tdevice;
  363. +            if (b->device->readb)
  364. +                /* device has DEVDRV calls beyond unselect */
  365. +                b->drvsize = offsetof (DEVDRV, readb) + sizeof (long);
  366.              b->private = arg;
  367.              b->flags = O_TTY;
  368.              *b->tty = default_tty;
  369. @@ -887,6 +921,7 @@
  370.               * who didn't recognize this change is still using it.
  371.               */
  372.              b->tty = 0;
  373. +            b->drvsize = 0;
  374.              b->device = &bios_ndevice;
  375.              b->private = arg;
  376.              b->flags = 0;
  377. @@ -1221,7 +1256,7 @@
  378.   * for cooked TTY output they will, which is the only sort that
  379.   * control characters affect anyways).
  380.   */
  381. -    if (bytes > 0 && (*r & 0x000000ffL) == '\n')
  382. +    if (bdev == 2 && bytes > 0 && (*r & 0x000000ffL) == '\n')
  383.          (void) checkkeys();
  384.  
  385.      if (f->flags & O_NDELAY) {
  386. @@ -1277,6 +1312,335 @@
  387.  }
  388.  
  389.  /*
  390. + * fast RAW byte IO for BIOS ttys
  391. + * without this a RAW tty read goes thru bios_tread for every single
  392. + * char, calling BIOS 3 times per byte at least...  a poor 8 MHz ST
  393. + * just can't move real 19200 bits per second that way, before a
  394. + * byte crawled thru all this the next has already arrived.
  395. + * if the device has xcon* calls and a `normal' iorec these functions
  396. + * access the buffers directly using as little CPU time as possible,
  397. + * for other devices they return EUNDEV (== do the slow thing then).
  398. + * yes it is a hack but better one hack here than hacks in every
  399. + * user process that wants good RAW IO performance...
  400. + */
  401. +
  402. +static long ARGS_ON_STACK 
  403. +bios_writeb(f, buf, bytes)
  404. +    FILEPTR *f; const char *buf; long bytes;
  405. +{
  406. +    int bdev = f->fc.aux;
  407. +    struct bios_file *b = (struct bios_file *)f->fc.index;
  408. +
  409. +    return iwrite (bdev, buf, bytes, (f->flags & O_NDELAY), b);
  410. +}
  411. +
  412. +/* FILEPTR-less entrypoint for bflush etc. */
  413. +
  414. +long
  415. +iwrite(bdev, buf, bytes, ndelay, b)
  416. +    int bdev; const char *buf; long bytes; int ndelay; struct bios_file *b;
  417. +{
  418. +    IOREC_T *ior = 0;
  419. +    long *cout = 0;    /* keep compiler happy */
  420. +    long *ospeed;
  421. +    const char *p = buf;
  422. +    int slept = 0;
  423. +
  424. +    if (has_bconmap) {
  425. +        if ((unsigned)bdev-6 < btty_max) {
  426. +            ior = MAPTAB[bdev-6].iorec + 1;
  427. +            cout = &MAPTAB[bdev-6].bconout;
  428. +            ospeed = &bttys[bdev-6].ospeed;
  429. +        }
  430. +    } else if (bdev == 1 && tosvers > 0x0102) {
  431. +        ior = bttys[0].orec;
  432. +        cout = &xconout[1];
  433. +        ospeed = &bttys[0].ospeed;
  434. +    }
  435. +
  436. +/* no iorec, fall back to the slow way... */
  437. +    if (!ior)
  438. +        return EUNDEV;
  439. +
  440. +    if (!buf) {
  441. +        /* flush send buffer...  should be safe to just set the
  442. +           tail pointer. */
  443. +        ior->tail = ior->head;
  444. +        return 0;
  445. +    }
  446. +
  447. +    if (!bytes)
  448. +        /* nothing to do... */
  449. +        return 0;
  450. +
  451. +    do {
  452. +        char ch;
  453. +        unsigned short tail, bsize, wrap, newtail;
  454. +        long free;
  455. +
  456. +        tail = ior->tail;
  457. +        bsize = ior->buflen;
  458. +        if ((free = (long)ior->head - tail - 1) < 0)
  459. +            free += bsize;
  460. +
  461. +        /* if buffer is full or we're blocking and can't write enuf */
  462. +        if ((unsigned long)free < 2 ||
  463. +            (!ndelay && free < bytes && free < bsize/2)) {
  464. +            long sleepchars;
  465. +            unsigned long isleep;
  466. +
  467. +            /* if the write should not block thats it. */
  468. +            if (ndelay)
  469. +                return p - buf;
  470. +
  471. +            /* else sleep the (minimum) time it takes until
  472. +               the buffer is either half-empty or has space
  473. +               enough for the write, wichever is smaller. */
  474. +            if ((sleepchars = bsize/2) > bytes)
  475. +                sleepchars = bytes;
  476. +            sleepchars -= free;
  477. +
  478. +            isleep = (unsigned long) ((sleepchars * 10000L) / *ospeed);
  479. +
  480. +            /* except that if we already slept and the buffer
  481. +               still was full we sleep for at least 20
  482. +               milliseconds. (driver must be waiting for
  483. +               some handshake signal and we don't want to
  484. +               hog the processor.) */
  485. +            if (slept && isleep < 20)
  486. +                isleep = 20;
  487. +
  488. +            if (isleep < 5)
  489. +                /* if it still would be less than 5
  490. +                   milliseconds then just give up this
  491. +                   timeslice */
  492. +                yield();
  493. +            else if (isleep < 20)
  494. +                nap (isleep);
  495. +            else {
  496. +                TIMEOUT *t;
  497. +
  498. +                if (isleep > 200)
  499. +                    isleep = 200;
  500. +                t = addtimeout((long)isleep, (void (*)(PROC *))wakeselect);
  501. +                if (t) {
  502. +                    sleep(SELECT_Q, (long)wakeselect);
  503. +                    canceltimeout(t);
  504. +                }
  505. +            }
  506. +
  507. +            /* loop and try again. */
  508. +            slept = (unsigned long)free < 2;
  509. +            continue;
  510. +        }
  511. +        slept = 0;
  512. +
  513. +        /* save the 1st char, we could need it later. */
  514. +        ch = *p;
  515. +        wrap = bsize - tail;
  516. +        if (--free > bytes)
  517. +            free = bytes;
  518. +        bytes -= free;
  519. +
  520. +        /* now copy to buffer.  if its just a few then do it here... */
  521. +        if (free < 5) {
  522. +            char *q = ior->bufaddr + tail;
  523. +
  524. +            while (free--) {
  525. +                if (!--wrap)
  526. +                    q -= bsize;
  527. +                *++q = *p++;
  528. +            }
  529. +            newtail = q - ior->bufaddr;
  530. +
  531. +        /* else use memcpy.  */
  532. +        } else {
  533. +            /* --wrap and tail+1 because tail is `inc before access' */
  534. +            if (--wrap < free) {
  535. +                memcpy (ior->bufaddr + tail + 1, p, wrap);
  536. +                memcpy (ior->bufaddr, p + wrap, free - wrap);
  537. +                newtail = free - wrap - 1;
  538. +            } else {
  539. +                memcpy (ior->bufaddr + tail + 1, p, free);
  540. +                newtail = tail + free;
  541. +            }
  542. +            p += free;
  543. +        }
  544. +
  545. +        /* the following has to be done with interrupts off to avoid
  546. +           race conditions. */
  547. +        {
  548. +            short sr = spl7();
  549. +
  550. +            /* if the buffer is empty there might be no
  551. +               interrupt that sends the next char, so we
  552. +               send it thru the xcon* vector. */
  553. +            if (ior->head == ior->tail) {
  554. +                (void) callout2(*cout, bdev, (unsigned char) ch);
  555. +
  556. +                /* if the buffer now is still empty set
  557. +                   the head pointer to skip the 1st char
  558. +                   (that we just sent). */
  559. +                if (ior->head == ior->tail) {
  560. +                    if (++tail >= bsize)
  561. +                        tail = 0;
  562. +                    ior->head = tail;
  563. +                }
  564. +            }
  565. +            ior->tail = newtail;
  566. +
  567. +            spl(sr);
  568. +            if (b) {
  569. +                b->xattr.mtime = b->xattr.atime = timestamp;
  570. +                b->xattr.mdate = b->xattr.adate = datestamp;
  571. +            }
  572. +        }
  573. +    /* if we're blocking loop until everything is written */
  574. +    } while (bytes && !ndelay);
  575. +
  576. +    return p - buf;
  577. +}
  578. +
  579. +/*
  580. + * fast RAW BIOS tty read
  581. + * this really works like a RAW tty read i.e. only blocks until _some_
  582. + * data is ready.
  583. + * TODO: implement termios VMIN, VTIME...
  584. + */
  585. +
  586. +static long ARGS_ON_STACK 
  587. +bios_readb(f, buf, bytes)
  588. +    FILEPTR *f; char *buf; long bytes;
  589. +{
  590. +    int bdev = f->fc.aux;
  591. +    struct bios_file *b = (struct bios_file *)f->fc.index;
  592. +
  593. +    return iread (bdev, buf, bytes, (f->flags & O_NDELAY), b);
  594. +}
  595. +
  596. +long
  597. +iread(bdev, buf, bytes, ndelay, b)
  598. +    int bdev; char *buf; long bytes; int ndelay; struct bios_file *b;
  599. +{
  600. +    IOREC_T *ior = 0;
  601. +    long *cin = 0;    /* keep compiler happy */
  602. +    long *cinstat;
  603. +    char *p;
  604. +    unsigned short head, bsize, wrap;
  605. +    long left;
  606. +
  607. +    if (bdev == 3 && tosvers > 0x0102) {
  608. +        /* midi */
  609. +        ior = (IOREC_T *) uiorec(2);
  610. +        cin = &xconin[3];
  611. +        cinstat = &xconstat[3];
  612. +    } else if (has_bconmap) {
  613. +        if ((unsigned)bdev-6 < btty_max) {
  614. +            ior = MAPTAB[bdev-6].iorec;
  615. +            cin = &MAPTAB[bdev-6].bconin;
  616. +            cinstat = &MAPTAB[bdev-6].bconstat;
  617. +        }
  618. +    } else if (bdev == 1 && tosvers > 0x0102) {
  619. +        ior = bttys[0].irec;
  620. +        cin = &xconin[1];
  621. +        cinstat = &xconstat[1];
  622. +    }
  623. +
  624. +/* no iorec, fall back to the slow way... */
  625. +    if (!ior)
  626. +        return EUNDEV;
  627. +
  628. +    if (buf && !bytes)
  629. +        /* nothing to do... */
  630. +        return 0;
  631. +
  632. +    /* if the read should block sleep until there is something to read */
  633. +    if (buf && !ndelay) {
  634. +        while (!(int)callout1(*cinstat, bdev)) {
  635. +            if (has_bconmap && (unsigned)bdev-6 < btty_max) {
  636. +                sleep(IO_Q, (long)&bttys[bdev-6]);
  637. +            } else if (bdev == 1) {
  638. +                sleep(IO_Q, (long)&bttys[0]);
  639. +            } else
  640. +                nap(60);
  641. +        }
  642. +    }
  643. +
  644. +    head = ior->head;
  645. +    if (!(left = ((unsigned long) ior->tail) - head)) {
  646. +        /* if the buffer is still empty we're finished... */
  647. +        return 0;
  648. +    }
  649. +
  650. +    /* now copy the data out of the buffer */
  651. +    bsize = ior->buflen;
  652. +    if (left < 0)
  653. +        left += bsize;
  654. +    wrap = bsize - head;
  655. +
  656. +    /* if we should flush input pretend we want to read it all */
  657. +    if (!buf && !bytes)
  658. +        bytes = left;
  659. +
  660. +    if (left > bytes)
  661. +        left = bytes;
  662. +
  663. +    /* if its just a few then do it here... */
  664. +    if (buf && left <= 5) {
  665. +        char *q = ior->bufaddr + head;
  666. +
  667. +        /* the --left in the while() makes us get one char less
  668. +           because we want to get the last one thru the driver
  669. +           so that it gets a chance to raise RTS or send XON... */
  670. +        p = buf;
  671. +        while (--left) {
  672. +            if (!--wrap)
  673. +                q -= bsize;
  674. +            *p++ = *++q;
  675. +        }
  676. +        ior->head = q - ior->bufaddr;
  677. +
  678. +    /* else memcpy is faster. */
  679. +    } else {
  680. +        /* --wrap and head+1 because head is `inc before access' */
  681. +        if (--wrap < --left) {
  682. +            if (buf) {
  683. +                memcpy (buf, ior->bufaddr + head + 1, wrap);
  684. +                memcpy (buf + wrap, ior->bufaddr, left - wrap);
  685. +            }
  686. +            ior->head = left - wrap - 1;
  687. +        } else {
  688. +            if (buf)
  689. +                memcpy (buf, ior->bufaddr + head + 1, left);
  690. +            ior->head = head + left;
  691. +        }
  692. +        /* p points to last char */
  693. +        p = buf + left;
  694. +    }
  695. +
  696. +    {
  697. +        short sr = spl7();
  698. +
  699. +        /* xconin[] are always blocking, and we don't want to
  700. +           hang at ipl7 even if something impossible like a
  701. +           `magically' empty buffer happens.  so check again. */
  702. +        if (ior->tail != ior->head)
  703. +            if (buf)
  704. +                *p++ = callout1(*cin, bdev);
  705. +            else
  706. +                (void) callout1(*cin, bdev);
  707. +        spl(sr);
  708. +        if (b) {
  709. +            b->xattr.atime = timestamp;
  710. +            b->xattr.adate = datestamp;
  711. +        }
  712. +    }
  713. +    if (!buf)
  714. +        return 0;
  715. +    return p - buf;
  716. +}
  717. +
  718. +/*
  719.   * read/write routines for BIOS devices that aren't terminals (like the
  720.   * printer & IKBD devices)
  721.   */
  722. @@ -1346,14 +1710,6 @@
  723.      return 0;
  724.  }
  725.  
  726. -#define MAXBAUD 16
  727. -
  728. -/* keep these sorted in descending order */
  729. -static long baudmap[MAXBAUD] = {
  730. -19200L, 9600L, 4800L, 3600L, 2400L, 2000L, 1800L, 1200L,
  731. -600L, 300L, 200L, 150L, 134L, 110L, 75L, 50L
  732. -};
  733. -
  734.  static long ARGS_ON_STACK 
  735.  bios_ioctl(f, mode, buf)
  736.      FILEPTR *f; int mode; void *buf;
  737. @@ -1395,16 +1751,23 @@
  738.              flushtype = (int) *r;
  739.          }
  740.          if (dev == 1 || dev >= 6) {
  741. +            b = (struct bios_file *)f->fc.index;
  742.              if (has_bconmap && dev >= 6)
  743.                  ior = MAPTAB[dev-6].iorec;
  744.              else
  745.                  ior = (IOREC_T *) uiorec(0);
  746. -            if (flushtype & 1) {
  747. +    /* just resetting iorec pointers here can hang a flow controlled port,
  748. +     * iread can do better...
  749. +     */
  750. +            if ((flushtype & 1) &&
  751. +                iread (dev, (char *) NULL, 0, 1, b) == EUNDEV) {
  752.                  sr = spl7();
  753.                  ior->head = ior->tail = 0;
  754.                  spl(sr);
  755.              }
  756. -            if (flushtype & 2) {
  757. +    /* sender should be ok but iwrite also sets the dev's ctime */
  758. +            if ((flushtype & 2) &&
  759. +                iwrite (dev, (char *) NULL, 0, 1, b) == EUNDEV) {
  760.                  ior++; /* output record */
  761.                  sr = spl7();
  762.                  ior->head = ior->tail = 0;
  763. Index: quickmov.spp
  764. @@ -6,14 +6,49 @@
  765.  ; quickly copy "nbytes" bytes from src to dst. Assumes that both
  766.  ; src and dst are word aligned.
  767.  ;
  768. +; quickmovb(char *dst, char *src, long nbytes):
  769. +; like memcpy, does unaligned too...  does not check for overlap (memmove).
  770. +;
  771.      TEXT
  772.  
  773.      XDEF    _quickmove
  774. +    XDEF    _quickmovb
  775.  
  776. +;%ifdef OWN_LIB
  777. +    XDEF    _bcopy
  778. +    XDEF    __bcopy
  779. +
  780. +_bcopy:
  781. +__bcopy:
  782. +    move.l    8(sp),a0        ; get dst
  783. +    move.l    4(sp),a1        ; get src
  784. +    bra.s    _quickmovb1
  785. +;%endif
  786. +
  787. +_quickmovb:
  788. +    move.l    4(sp),a0        ; get dst
  789. +    move.l    8(sp),a1        ; get src
  790. +_quickmovb1:
  791. +    move.w    a0,d0
  792. +    move.w    a1,d1
  793. +    eor.w    d1,d0            ; bit 0 == unaligned
  794. +    lsr.w    #1,d0            ; ...now in x flag
  795. +    move.l    12(sp),d0        ; get nbytes
  796. +    beq.s    Ldone
  797. +    roxr.w    #1,d1            ; bit 0 == both odd, msb == unaligned
  798. +    bmi.s    bytecopy        ; unaligned, do the slow thing...
  799. +    bcc.s    quickmov1        ; both even, ok
  800. +    subq.l    #1,d0            ; both odd, can be fixed
  801. +    move.b    (a1)+,(a0)+
  802. +    bra.s    quickmov1
  803. +
  804.  _quickmove:
  805.      move.l    4(sp),a0        ; get dst
  806.      move.l    8(sp),a1        ; get src
  807.      move.l    12(sp),d0        ; get nbytes
  808. +quickmov1:
  809. +    move.w    #$1ff,d1
  810. +    and.w    d0,d1            ; d1 = nbytes % 512
  811.      lsr.l    #8,d0            ; 
  812.      lsr.l    #1,d0            ; d0 = nbytes / 512
  813.      subq.l    #1,d0            ; prepare for dbra loop
  814. @@ -50,13 +85,34 @@
  815.      movem.l    (sp)+,d1-d7/a2-a6    ; pop registers
  816.  
  817.  Leftover:                ; do the remaining bytes
  818. -    move.l    12(sp),d1
  819. -    and.w    #$01ff,d1        ; d1 = nbytes % 512
  820. +    moveq.l    #3,d0
  821. +    and.w    d1,d0
  822. +    lsr.w    #2,d1
  823.      subq.w    #1,d1            ; prepare for dbra loop
  824. +    bmi.s    L4done
  825. +    lsr.w    #1,d1
  826. +    bcc.s    L23
  827. +L2l:
  828. +    move.l    (a1)+,(a0)+
  829. +L23:
  830. +    move.l    (a1)+,(a0)+
  831. +    dbra    d1,L2l
  832. +L4done:
  833. +    subq.w    #1,d0            ; prepare for dbra loop
  834.      bmi.s    Ldone
  835.  L2:
  836.      move.b    (a1)+,(a0)+
  837. -    dbra    d1,L2
  838. +    dbra    d0,L2
  839.  Ldone:
  840.      rts                ; return
  841. +
  842. +bytecopy:
  843. +    subq.l    #1,d0            ; prepare for dbra loop
  844. +    move.l    d0,d1
  845. +    swap    d1
  846. +L3:
  847. +    move.b    (a1)+,(a0)+
  848. +    dbra    d0,L3
  849. +    dbra    d1,L3
  850. +    rts                ; return
  851.      END
  852. Index: sproto.h
  853. @@ -29,6 +29,7 @@
  854.  
  855.  /* quickmov.s */
  856.  void ARGS_ON_STACK quickmove P_((void *dst, void *src, long nbytes));
  857. +void ARGS_ON_STACK quickmovb P_((void *dst, const void *src, long nbytes));
  858.  
  859.  /* syscall.s */
  860.  char * ARGS_ON_STACK lineA0 P_((void));
  861. Index: tty.c
  862. @@ -87,6 +87,7 @@
  863.      unsigned char ch, *ptr;
  864.      int rdmode, mode;
  865.      struct tty *tty;
  866. +    extern FILESYS bios_filesys;
  867.  
  868.      tty = (struct tty *)f->devinfo;
  869.      assert(tty != 0);
  870. @@ -108,6 +109,21 @@
  871.          rdmode = COOKED|NOECHO;
  872.          mode = T_TOS | T_ECHO;
  873.      }
  874. +#if 1
  875. +    /* see if we can do fast RAW byte IO thru the device driver... */
  876. +    if (rdmode == RAW && !(tty->state & TS_ESC) &&
  877. +        (f->fc.fs != &bios_filesys ||
  878. +        (nbytes > 1 &&
  879. +         ((struct bios_file *)f->fc.index)->drvsize >
  880. +            offsetof (DEVDRV, readb))) &&
  881. +        *f->dev->readb &&
  882. +        ((f->flags & O_HEAD) ||
  883. +        !tty->pgrp || tty->pgrp == curproc->pgrp ||
  884. +        f->fc.dev != curproc->control->fc.dev ||
  885. +        f->fc.index != curproc->control->fc.index) &&
  886. +        (bytes_read = (*f->dev->readb)(f, buf, nbytes)) != EUNDEV)
  887. +        return bytes_read;
  888. +#endif
  889.  
  890.      ptr = buf;
  891.  
  892. @@ -243,6 +259,31 @@
  893.      return bytes_read;
  894.  }
  895.  
  896. +/* job control checks */
  897. +/* AKP: added T_TOSTOP; don't stop BG output if T_TOSTOP is clear */
  898. +/*
  899. +entropy: only do the job control if SIGTTOU is neither blocked nor ignored,
  900. +and only for the controlling tty (IEEE 1003.1-1990 7.1.1.4 79-87).
  901. +BUG:  if the process group is orphaned and SIGTTOU *is not* blocked
  902. +or ignored, we should return EIO instead of signalling.
  903. +*/
  904. +INLINE void
  905. +tty_checkttou (f, tty)
  906. +    FILEPTR *f;
  907. +    struct tty *tty;
  908. +{
  909. +    if (tty->pgrp && tty->pgrp != curproc->pgrp &&
  910. +             (tty->sg.sg_flags & T_TOSTOP) &&
  911. +                 (curproc->sighandle[SIGTTOU] != SIG_IGN) &&
  912. +                 ((curproc->sigmask & (1L << SIGTTOU)) == 0L) &&
  913. +                 (f->fc.dev == curproc->control->fc.dev) &&
  914. +                 (f->fc.index == curproc->control->fc.index)) {
  915. +        TRACE(("job control: tty pgrp is %d proc pgrp is %d",
  916. +            tty->pgrp, curproc->pgrp));
  917. +        killgroup(curproc->pgrp, SIGTTOU);
  918. +    }
  919. +}
  920. +
  921.  long
  922.  tty_write(f, buf, nbytes)
  923.      FILEPTR *f;
  924. @@ -258,6 +299,7 @@
  925.      static long cr_char = '\r';
  926.  #define LBUFSIZ 128
  927.      long lbuf[LBUFSIZ];
  928. +    extern FILESYS bios_filesys;
  929.  
  930.      tty = (struct tty *)f->devinfo;
  931.      assert(tty != 0);
  932. @@ -286,6 +328,20 @@
  933.      else
  934.          mode = 0;
  935.  
  936. +#if 1
  937. +    /* see if we can do fast RAW byte IO thru the device driver... */
  938. +    if (!mode && !use_putchar &&
  939. +        (f->fc.fs != &bios_filesys ||
  940. +        (nbytes > 1 && rwmode == RAW &&
  941. +         ((struct bios_file *)f->fc.index)->drvsize >
  942. +            offsetof (DEVDRV, writeb))) && *f->dev->writeb) {
  943. +
  944. +        tty_checkttou (f, tty);
  945. +        if ((bytes_written = (*f->dev->writeb)(f, buf, nbytes)) != EUNDEV)
  946. +            return bytes_written;
  947. +    }
  948. +#endif
  949. +
  950.  /*
  951.   * we always write at least 1 byte with tty_putchar, since that takes
  952.   * care of job control and terminal states. After that, we may be able
  953. @@ -801,6 +857,9 @@
  954.          }
  955.          goto do_putchar;
  956.      }
  957. +#if 1
  958. +    tty_checkttou (f, tty);
  959. +#else
  960.  /* job control checks */
  961.  /* AKP: added T_TOSTOP; don't stop BG output if T_TOSTOP is clear */
  962.  /*
  963. @@ -819,6 +878,7 @@
  964.              tty->pgrp, curproc->pgrp));
  965.          killgroup(curproc->pgrp, SIGTTOU);
  966.      }
  967. +#endif
  968.  
  969.      if (mode & COOKED) {
  970.          tty->state |= TS_COOKED;
  971. Index: types.h
  972. @@ -16,7 +16,9 @@
  973.  /* structure used to hold i/o buffers */
  974.  typedef struct io_rec {
  975.      char *bufaddr;
  976. -    short buflen, head, tail, low_water, hi_water;
  977. +    short buflen;
  978. +    volatile short head, tail;
  979. +    short low_water, hi_water;
  980.  } IOREC_T;
  981.  
  982.  /* Bconmap struct, * returned by Bconmap(-2) */
  983. Index: xbios.c
  984. @@ -104,6 +104,21 @@
  985.      if (!f) return EIHNDL;
  986.  
  987.      if (is_terminal(f)) {
  988. +#if 1
  989. +        extern FILESYS bios_filesys;
  990. +
  991. +        /* see if we can do fast RAW byte IO thru the device driver... */
  992. +        if ((f->fc.fs != &bios_filesys ||
  993. +            (towrite > 1 &&
  994. +             ((struct bios_file *)f->fc.index)->drvsize >
  995. +                offsetof (DEVDRV, writeb))) && *f->dev->writeb) {
  996. +            struct tty *tty = (struct tty *)f->devinfo;
  997. +
  998. +            tty_checkttou (f, tty);
  999. +            if ((towrite = (*f->dev->writeb)(f, buf, towrite)) != EUNDEV)
  1000. +                return towrite;
  1001. +        }
  1002. +#endif
  1003.          while (cnt >= 0) {
  1004.              tty_putchar(f, (long)*buf, RAW);
  1005.              buf++; cnt--;
  1006. @@ -163,7 +178,7 @@
  1007.  {
  1008.      long rsval;
  1009.      static int oldbaud = -1;
  1010. -    int ret_oldbaud = 0;
  1011. +    int b, ret_oldbaud = 0;
  1012.      extern struct tty ttmfp_tty;
  1013.      extern struct bios_tty bttys[];
  1014.      extern short btty_max;
  1015. @@ -230,6 +245,10 @@
  1016.      rsval = Rsconf(baud, flow, uc, rs, ts, sc);
  1017.      if (ret_oldbaud)
  1018.          rsval = (long) oldbaud;
  1019. +    b = 0;
  1020. +    if (baud >= 0 &&
  1021. +        (!has_bconmap || (unsigned)(b = curproc->bconmap-6) < btty_max))
  1022. +        bttys[b].ospeed = bttys[b].ispeed = (unsigned)baud<bttys[b].maxbaud ? bttys[b].baudmap[baud] : -1;
  1023.  
  1024.      return rsval;
  1025.  }
  1026.  
  1027. 3. ptys can also have readb+writeb (for the slave->master pipe), and
  1028. use memcpy too (all pipes).  and really buffer 4K not 4K - 1 byte so the
  1029. copies are aligned more often...
  1030.  
  1031. Index: pipefs.c
  1032. @@ -35,6 +35,10 @@
  1033.  static long    ARGS_ON_STACK pipe_open    P_((FILEPTR *f));
  1034.  static long    ARGS_ON_STACK pipe_write    P_((FILEPTR *f, const char *buf, long bytes));
  1035.  static long    ARGS_ON_STACK pipe_read    P_((FILEPTR *f, char *buf, long bytes));
  1036. +static long    ARGS_ON_STACK pty_write        P_((FILEPTR *f, const char *buf, long bytes));
  1037. +static long    ARGS_ON_STACK pty_read    P_((FILEPTR *f, char *buf, long bytes));
  1038. +static long    ARGS_ON_STACK pty_writeb    P_((FILEPTR *f, const char *buf, long bytes));
  1039. +static long    ARGS_ON_STACK pty_readb    P_((FILEPTR *f, char *buf, long bytes));
  1040.  static long    ARGS_ON_STACK pipe_lseek    P_((FILEPTR *f, long where, int whence));
  1041.  static long    ARGS_ON_STACK pipe_ioctl    P_((FILEPTR *f, int mode, void *buf));
  1042.  static long    ARGS_ON_STACK pipe_datime    P_((FILEPTR *f, short *time, int rwflag));
  1043. @@ -47,8 +51,10 @@
  1044.      pipe_close, pipe_select, pipe_unselect
  1045.  };
  1046.  
  1047. -/* ptys and pipes can share the same driver, for now */
  1048. -#define pty_device pipe_device
  1049. +DEVDRV pty_device = {
  1050. +    pipe_open, pty_write, pty_read, pipe_lseek, pipe_ioctl, pipe_datime,
  1051. +    pipe_close, pipe_select, pipe_unselect, pty_writeb, pty_readb
  1052. +};
  1053.  
  1054.  FILESYS pipe_filesys = {
  1055.      (FILESYS *)0,
  1056. @@ -79,7 +85,7 @@
  1057.      int    head, tail;    /* pipe head, tail (head == tail for empty) */
  1058.      long    rsel;        /* process that did select() for reads */
  1059.      long    wsel;        /* process that did select() for writes */
  1060. -    char    buf[PIPESIZ];    /* pipe data */
  1061. +    char    buf[PIPESIZ+4];    /* pipe data */
  1062.  };
  1063.  
  1064.  struct fifo {
  1065. @@ -610,8 +616,8 @@
  1066.      if (nbytes > 0 && nbytes <= PIPE_BUF) {
  1067.  check_atomicity:
  1068.          r = p->tail - p->head;
  1069. -        if (r < 0) r += PIPESIZ;
  1070. -        r = (PIPESIZ-1) - r; /* r is the number of bytes we can write */
  1071. +        if (r < 0) r += PIPESIZ+4;
  1072. +        r = PIPESIZ - r; /* r is the number of bytes we can write */
  1073.          if (r < nbytes) {
  1074.      /* check for broken pipes */
  1075.              if (p->readers == 0 || p->readers == VIRGIN_PIPE) {
  1076. @@ -635,9 +641,48 @@
  1077.  
  1078.      while (nbytes > 0) {
  1079.          ptail = p->tail; phead = p->head;
  1080. -        j = ptail+1;
  1081. -        if (j >= PIPESIZ) j = 0;
  1082. +        j = ptail+4;
  1083. +        if (j >= PIPESIZ+4) j -= PIPESIZ+4;
  1084.          if (j != phead) {
  1085. +#if 1
  1086. +            int free, wrap;
  1087. +
  1088. +            pbuf = p->buf + ptail;
  1089. +            if ((free = phead - j) < 0)
  1090. +                free += PIPESIZ+4;
  1091. +            if (free == PIPESIZ && ((j = ((long)pbuf & 3)))) {
  1092. +    /* if pipe empty we can align pointers */
  1093. +                if ((ptail += 4-j) >= PIPESIZ+4)
  1094. +                    ptail -= PIPESIZ+4;
  1095. +                p->head = phead = ptail;
  1096. +                pbuf = p->buf + ptail;
  1097. +            }
  1098. +            if (free > nbytes)
  1099. +                free = nbytes;
  1100. +            nbytes -= free;
  1101. +            bytes_written += free;
  1102. +
  1103. +            wrap = PIPESIZ+4 - ptail;
  1104. +            if (free < 5) {
  1105. +                while (free--) {
  1106. +                    *pbuf++ = *buf++;
  1107. +                    if (!--wrap)
  1108. +                        pbuf -= PIPESIZ+4;
  1109. +                }
  1110. +                ptail = pbuf - p->buf;
  1111. +            } else {
  1112. +                if (wrap <= free) {
  1113. +                    memcpy (pbuf, buf, wrap);
  1114. +                    memcpy (p->buf, buf + wrap, free - wrap);
  1115. +                    ptail = free - wrap;
  1116. +                } else {
  1117. +                    memcpy (pbuf, buf, free);
  1118. +                    ptail += free;
  1119. +                }
  1120. +                buf += free;
  1121. +            }
  1122. +#else
  1123. +            j -= 3;
  1124.              pbuf = &p->buf[ptail];
  1125.              do {
  1126.                  *pbuf++ = *buf++;
  1127. @@ -645,8 +690,9 @@
  1128.                  if ( (ptail = j) == 0 )
  1129.                      pbuf = &p->buf[0];
  1130.                  j++;
  1131. -                if (j >= PIPESIZ) j = 0;
  1132. +                if (j >= PIPESIZ+4) j = 0;
  1133.              } while ( (nbytes > 0) && (j != phead) );
  1134. +#endif
  1135.              p->tail = ptail;
  1136.          } else {        /* pipe full */
  1137.              if (p->readers == 0 || p->readers == VIRGIN_PIPE) {
  1138. @@ -706,16 +752,48 @@
  1139.      while (nbytes > 0) {
  1140.          phead = p->head; ptail = p->tail;
  1141.          if (ptail != phead) {
  1142. +#if 1
  1143. +            int left, wrap;
  1144. +
  1145. +            pbuf = p->buf + phead;
  1146. +            if ((left = ptail - phead) < 0)
  1147. +                left += PIPESIZ+4;
  1148. +            if (left > nbytes)
  1149. +                left = nbytes;
  1150. +            nbytes -= left;
  1151. +            bytes_read += left;
  1152. +
  1153. +            wrap = PIPESIZ+4 - phead;
  1154. +            if (left <= 5) {
  1155. +                while (left--) {
  1156. +                    *buf++ = *pbuf++;
  1157. +                    if (!--wrap)
  1158. +                        pbuf -= PIPESIZ+4;
  1159. +                }
  1160. +                phead = pbuf - p->buf;
  1161. +            } else {
  1162. +                if (wrap <= left) {
  1163. +                    memcpy (buf, pbuf, wrap);
  1164. +                    memcpy (buf + wrap, p->buf, left - wrap);
  1165. +                    phead = left - wrap;
  1166. +                } else {
  1167. +                    memcpy (buf, pbuf, left);
  1168. +                    phead += left;
  1169. +                }
  1170. +                buf += left;
  1171. +            }
  1172. +#else
  1173.              pbuf = &p->buf[phead];
  1174.              do {
  1175.                  *buf++ = *pbuf++;
  1176.                  nbytes--; bytes_read++;
  1177.                  phead++;
  1178. -                if (phead >= PIPESIZ) {
  1179. +                if (phead >= PIPESIZ+4) {
  1180.                      phead = 0;
  1181.                      pbuf = &p->buf[phead];
  1182.                  }
  1183.              } while ( (nbytes > 0) && (phead != ptail) );
  1184. +#endif
  1185.              p->head = phead;
  1186.          }
  1187.          else if (p->writers <= 0 || p->writers == VIRGIN_PIPE) {
  1188. @@ -752,6 +830,64 @@
  1189.  }
  1190.  
  1191.  static long ARGS_ON_STACK 
  1192. +pty_write(f, buf, nbytes)
  1193. +    FILEPTR *f; const char *buf; long nbytes;
  1194. +{
  1195. +    long bytes_written = 0;
  1196. +
  1197. +    if (!nbytes)
  1198. +        return 0;
  1199. +    if (f->flags & O_HEAD)
  1200. +        return pipe_write(f, buf, nbytes);
  1201. +    if (nbytes != 4)
  1202. +        ALERT("pty_write: slave nbytes != 4");
  1203. +    bytes_written = pipe_write(f, buf+3, 1);
  1204. +    if (bytes_written == 1)
  1205. +        bytes_written = 4;
  1206. +    return bytes_written;
  1207. +}
  1208. +
  1209. +static long ARGS_ON_STACK 
  1210. +pty_read(f, buf, nbytes)
  1211. +    FILEPTR *f; char *buf; long nbytes;
  1212. +{
  1213. +    long bytes_read = 0;
  1214. +
  1215. +    if (!nbytes)
  1216. +        return 0;
  1217. +    if (!(f->flags & O_HEAD))
  1218. +        return pipe_read(f, buf, nbytes);
  1219. +    if (nbytes != 4)
  1220. +        ALERT("pty_read: master nbytes != 4");
  1221. +    bytes_read = pipe_read(f, buf+3, 1);
  1222. +    if (bytes_read == 1)
  1223. +        bytes_read = 4;
  1224. +    return bytes_read;
  1225. +}
  1226. +
  1227. +static long ARGS_ON_STACK 
  1228. +pty_writeb(f, buf, nbytes)
  1229. +    FILEPTR *f; const char *buf; long nbytes;
  1230. +{
  1231. +    if (!nbytes)
  1232. +        return 0;
  1233. +    if (f->flags & O_HEAD)
  1234. +        return EUNDEV;
  1235. +    return pipe_write(f, buf, nbytes);
  1236. +}
  1237. +
  1238. +static long ARGS_ON_STACK 
  1239. +pty_readb(f, buf, nbytes)
  1240. +    FILEPTR *f; char *buf; long nbytes;
  1241. +{
  1242. +    if (!nbytes)
  1243. +        return 0;
  1244. +    if (!(f->flags & O_HEAD))
  1245. +        return EUNDEV;
  1246. +    return pipe_read(f, buf, nbytes);
  1247. +}
  1248. +
  1249. +static long ARGS_ON_STACK 
  1250.  pipe_ioctl(f, mode, buf)
  1251.      FILEPTR *f; int mode; void *buf;
  1252.  {
  1253. @@ -772,8 +908,8 @@
  1254.                  r = -1;
  1255.              } else {
  1256.                  r = p->tail - p->head;
  1257. -                if (r < 0) r += PIPESIZ;
  1258. -                if (is_terminal(f))
  1259. +                if (r < 0) r += PIPESIZ+4;
  1260. +                if (is_terminal(f) && !(f->flags & O_HEAD))
  1261.                      r = r >> 2;    /* r /= 4 */
  1262.                  if (!r && p->writers <= 0) {
  1263.                      DEBUG(("pipe FIONREAD: no writers"));
  1264. @@ -789,9 +925,9 @@
  1265.                  r = -1;
  1266.              } else {
  1267.                  r = p->tail - p->head;
  1268. -                if (r < 0) r += PIPESIZ;
  1269. -                r = (PIPESIZ-1) - r;
  1270. -                if (is_terminal(f))
  1271. +                if (r < 0) r += PIPESIZ+4;
  1272. +                r = PIPESIZ - r;
  1273. +                if (is_terminal(f) && (f->flags & O_HEAD))
  1274.                      r = r >> 2;    /* r /= 4 */
  1275.              }
  1276.              *((long *) buf) = r;
  1277. @@ -867,8 +1003,8 @@
  1278.                  r = -1;
  1279.              } else {
  1280.                  r = p->tail - p->head;
  1281. -                if (r < 0) r += PIPESIZ;
  1282. -                if (is_terminal(f))
  1283. +                if (r < 0) r += PIPESIZ+4;
  1284. +                if (is_terminal(f) && (f->flags & O_HEAD))
  1285.                      r = r >> 2;    /* r /= 4 */
  1286.              }
  1287.              *((long *) buf) = r;
  1288. @@ -1081,8 +1217,8 @@
  1289.              DEBUG(("write select on wrong end of pipe"));
  1290.              return 0;
  1291.          }
  1292. -        j = p->tail+1;
  1293. -        if (j >= PIPESIZ) j = 0;
  1294. +        j = p->tail+4;
  1295. +        if (j >= PIPESIZ+4) j -= PIPESIZ+4;
  1296.          if (j != p->head || p->readers <= 0)
  1297.              return 1;    /* data may be written */
  1298.          if (p->wsel)
  1299. Index: tty.c
  1300. @@ -330,14 +330,50 @@
  1301.  
  1302.  #if 1
  1303.      /* see if we can do fast RAW byte IO thru the device driver... */
  1304. -    if (!mode && !use_putchar &&
  1305. +    if (!use_putchar &&
  1306.          (f->fc.fs != &bios_filesys ||
  1307. -        (nbytes > 1 && rwmode == RAW &&
  1308. -         ((struct bios_file *)f->fc.index)->drvsize >
  1309. +        (((struct bios_file *)f->fc.index)->drvsize >
  1310.              offsetof (DEVDRV, writeb))) && *f->dev->writeb) {
  1311.  
  1312.          tty_checkttou (f, tty);
  1313. -        if ((bytes_written = (*f->dev->writeb)(f, buf, nbytes)) != EUNDEV)
  1314. +        if (mode) {    /* i.e. T_CRMODE */
  1315. +            if ((*f->dev->writeb)(f, buf, 0L) != EUNDEV) {
  1316. +    /* write in big chunks if possible; lines if CRMODE
  1317. +     * (if we get here flow control is taken care of by the device)
  1318. +     */
  1319. +                long bytes_to_write = 0;
  1320. +                unsigned const char *s = ptr;
  1321. +
  1322. +                while (nbytes-- > 0) {
  1323. +                    if (*ptr++ == '\n') {
  1324. +                        if ((bytes_to_write = ptr-s-1)) {
  1325. +                            c = (*f->dev->writeb)(f, s,
  1326. +                                bytes_to_write);
  1327. +                            bytes_written += c;
  1328. +                            if (c != bytes_to_write) {
  1329. +                                if (c < 0)
  1330. +                                    bytes_written = c;
  1331. +                                return bytes_written;
  1332. +                            }
  1333. +                        }
  1334. +                        s = ptr-1;
  1335. +                        c = (*f->dev->writeb)(f, "\r", 1);
  1336. +                        if (c != 1) {
  1337. +                            if (c < 0)
  1338. +                                bytes_written = c;
  1339. +                            return bytes_written;
  1340. +                        }
  1341. +                    }
  1342. +                }
  1343. +                if ((bytes_to_write = ptr-s)) {
  1344. +                    c = (*f->dev->writeb)(f, s, bytes_to_write);
  1345. +                    bytes_written += c;
  1346. +                    if (c < 0)
  1347. +                        bytes_written = c;
  1348. +                }
  1349. +                return bytes_written;
  1350. +            }
  1351. +        } else if ((bytes_written = (*f->dev->writeb)(f, buf, nbytes)) != EUNDEV)
  1352.              return bytes_written;
  1353.      }
  1354.  #endif
  1355. Index: biosfs.c
  1356. @@ -1331,6 +1331,11 @@
  1357.      int bdev = f->fc.aux;
  1358.      struct bios_file *b = (struct bios_file *)f->fc.index;
  1359.  
  1360. +/* do the slow thing if tty is not in RAW mode until serial lines
  1361. + * handle control chars properly
  1362. + */
  1363. +    if (!(((struct tty *)f->devinfo)->sg.sg_flags & T_RAW))
  1364. +        return EUNDEV;
  1365.      return iwrite (bdev, buf, bytes, (f->flags & O_NDELAY), b);
  1366.  }
  1367.  
  1368. > 
  1369. > Kay.
  1370.  good luck
  1371.     Juergen
  1372. -- 
  1373. J"urgen Lock / nox@jelal.north.de / UUCP: ..!uunet!unido!uniol!jelal!nox
  1374.                                 ...ohne Gewehr
  1375. PGP public key fingerprint =  8A 18 58 54 03 7B FC 12  1F 8B 63 C7 19 27 CF DA 
  1376.